Read dev Docs 博客

# C++ nlohmann::json库使用教程

(adsbygoogle = window.adsbygoogle || []).push({});

目录

C++ json库用得比较多的是nlohmann::json库，支持现代C++版本，使用方便，只需要引入一个头文件。

# 下载

库地址：https://github.com/nlohmann/json/releases (opens new window)

下载json.hpp放在工程里

# 引入代码

#include <fstream>
#include <nlohmann/json.hpp>
using json = nlohmann::json;

# 读取JSON文件

#include <fstream>
#include <nlohmann/json.hpp>
using json = nlohmann::json;

// ...

std::ifstream f("example.json");
json data = json::parse(f);

# 从JSON文本创建JSON对象

假设您要在文件中创建此文本 JSON 值作为对象：

{
  "pi": 3.141,
  "happy": true
}

有多种选择：

// 用原始字符串和json::parse进行初始化
json ex1 = json::parse(R"(
  {
    "pi": 3.141,
    "happy": true
  }
)");

// 用原始字符串和literals进行初始化
using namespace nlohmann::literals;
json ex2 = R"(
  {
    "pi": 3.141,
    "happy": true
  }
)"_json;

// 使用初始化列表
json ex3 = {
  {"happy", true},
  {"pi", 3.141},
};

# JSON 作为第一类数据类型

下面是一些示例，可让您了解如何使用该类。

假设您要创建 JSON 对象

{
  "pi": 3.141,
  "happy": true,
  "name": "Niels",
  "nothing": null,
  "answer": {
    "everything": 42
  },
  "list": [1, 0, 2],
  "object": {
    "currency": "USD",
    "value": 42.99
  }
}

使用此库，您可以编写：

// 创建一个空json对象 (null)
json j;

// 添加一个double类型成员
j["pi"] = 3.141;

// 添加一个bool类型成员
j["happy"] = true;

// 添加一个字符串类型成员
j["name"] = "Niels";

// 添加一个空成员
j["nothing"] = nullptr;

// 添加一个对象中的对象成员：{"answer":{"everything":42}}
j["answer"]["everything"] = 42;

// 添加一个数组对象，使用vector类型
j["list"] = { 1, 0, 2 };

// 添加一个对象，使用初始化列表：{"object":{"currency": "USD","value":42.99}}
j["object"] = { {"currency", "USD"}, {"value", 42.99} };

// 也可以一次写完 
json j2 = {
  {"pi", 3.141},
  {"happy", true},
  {"name", "Niels"},
  {"nothing", nullptr},
  {"answer", {
    {"everything", 42}
  }},
  {"list", {1, 0, 2}},
  {"object", {
    {"currency", "USD"},
    {"value", 42.99}
  }}
};

请注意，在所有这些情况下，您永远不需要“告诉”编译器要使用哪种 JSON 值类型。如果你想明确或表达一些边缘情况，函数json::array（）和json::object（）会有所帮助：

// 初始化一个空数组对象
json empty_array_explicit = json::array();

// 初始化一个对象
json empty_object_implicit = json({});
json empty_object_explicit = json::object();

// 初始化数组键值对 [["currency", "USD"], ["value", 42.99]]
json array_not_object = json::array({ {"currency", 
"USD"}, {"value", 42.99} });

# 序列化/反序列化

# JSON对象和string互转

您可以通过追加到字符串文本来创建 JSON 值（反序列化）：_json

using namespace nlohmann::literals;

// 从字符串创建json对象
json j = "{ \"happy\": true, \"pi\": 3.141 }"_json;

// 使用原始字符串创建json对象
auto j2 = R"(
  {
    "happy": true,
    "pi": 3.141
  }
)"_json;

请注意，如果不附加后缀，则传递的字符串文字不会被解析，而只是用作 JSON 字符串 价值。也就是说，只会存储字符串而不是解析实际对象。_jsonjson j = "{ \"happy\": true, \"pi\": 3.141 }""{ "happy": true, "pi": 3.141 }"

上面的例子也可以用json::parse()显式表示：

auto j3 = json::parse(R"({"happy": true, "pi": 3.141})");

获取 JSON 字符串（序列化）：

std::string s = j.dump();    // {"happy":true,"pi":3.141}

// 序列化美化json形式
// 传入数字指定缩进空格数
std::cout << j.dump(4) << std::endl;
// {
//     "happy": true,
//     "pi": 3.141
// }

# 流输入输出（例如文件读写、字符串流）

您还可以使用流来序列化和反序列化：

// 从标准输入中反序列化
json j;
std::cin >> j;

// 序列化到标准输出
std::cout << j;

// 美化输出
std::cout << std::setw(4) << j << std::endl;

文件读写json：std::istream，std::ostream

// 读取json文件
std::ifstream i("file.json");
json j;
i >> j;

//json对象美化输出到文件
std::ofstream o("pretty.json");
o << std::setw(4) << j << std::endl;

从迭代器范围读取json

可以从迭代器范围解析 JSON;也就是说，从迭代器可访问的任何容器中，迭代器是 1、2 或 4 个字节的整数类型，将分别解释为 UTF-8、UTF-16 和 UTF-32。例如，std::vector<std::uint8_t>,std::list<std::uint16_t>

std::vector<std::uint8_t> v = {'t', 'r', 'u', 'e'};
json j = json::parse(v.begin(), v.end());

std::vector<std::uint8_t> v = {'t', 'r', 'u', 'e'};
json j = json::parse(v);

# 自定义数据源

由于 parse 函数接受任意迭代器范围，因此您可以通过实现概念来提供自己的数据源。LegacyInputIterator

struct MyContainer {
  void advance();
  const char& get_current();
};

struct MyIterator {
    using difference_type = std::ptrdiff_t;
    using value_type = char;
    using pointer = const char*;
    using reference = const char&;
    using iterator_category = std::input_iterator_tag;

    MyIterator& operator++() {
        MyContainer.advance();
        return *this;
    }

    bool operator!=(const MyIterator& rhs) const {
        return rhs.target != target;
    }

    reference operator*() const {
        return target.get_current();
    }

    MyContainer* target = nullptr;
};

MyIterator begin(MyContainer& tgt) {
    return MyIterator{&tgt};
}

MyIterator end(const MyContainer&) {
    return {};
}

void foo() {
    MyContainer c;
    json j = json::parse(c);
}
(adsbygoogle = window.adsbygoogle || []).push({});

# 类似 STL 的访问

我们将 JSON 类设计为类似于 STL 容器的行为。事实上，它满足可逆容器的要求。

// 用push_back创建一个数组对象
json j;
j.push_back("foo");
j.push_back(1);
j.push_back(true);

// 使用 emplace_back
j.emplace_back(1.78);

// 迭代访问
for (json::iterator it = j.begin(); it != j.end(); ++it) {
  std::cout << *it << '\n';
}

// 范围迭代
for (auto& element : j) {
  std::cout << element << '\n';
}

// getter/setter接口
const auto tmp = j[0].get<std::string>();
j[1] = 42;
bool foo = j.at(2);

// 比较
j == R"(["foo", 1, true, 1.78])"_json;  // true

// 其他
j.size();     // 4 个对象
j.empty();    // 是否为空：false
j.type();     // 获取类型：json::value_t::array
j.clear();    // 清空

// 检查类型
j.is_null();
j.is_boolean();
j.is_number();
j.is_object();
j.is_array();
j.is_string();

// 创建一个对象
json o;
o["foo"] = 23;
o["bar"] = false;
o["baz"] = 3.141;

// 使用 emplace
o.emplace("weather", "sunny");

// 迭代访问
for (json::iterator it = o.begin(); it != o.end(); ++it) {
  std::cout << it.key() << " : " << it.value() << "\n";
}

// 循环访问
for (auto& el : o.items()) {
  std::cout << el.key() << " : " << el.value() << "\n";
}

// 匿名对象迭代器(C++17)
for (auto& [key, value] : o.items()) {
  std::cout << key << " : " << value << "\n";
}

// 查找key
if (o.contains("foo")) {
  // 找到foo的键值
}

// 通过迭代器查找
if (o.find("foo") != o.end()) {
  // 找到foo的键值
}

// 用count()统计是否有键值
int foo_present = o.count("foo"); // 1
int fob_present = o.count("fob"); // 0

// 删除foo对象
o.erase("foo");

# 从 STL 容器转换

从STL容器转换到json，std::list转json，std::vector转json

std::vector<int> c_vector {1, 2, 3, 4};
json j_vec(c_vector);
// [1, 2, 3, 4]

std::deque<double> c_deque {1.2, 2.3, 3.4, 5.6};
json j_deque(c_deque);
// [1.2, 2.3, 3.4, 5.6]

std::list<bool> c_list {true, true, false, true};
json j_list(c_list);
// [true, true, false, true]

std::forward_list<int64_t> c_flist {12345678909876, 23456789098765, 34567890987654, 45678909876543};
json j_flist(c_flist);
// [12345678909876, 23456789098765, 34567890987654, 45678909876543]

std::array<unsigned long, 4> c_array {{1, 2, 3, 4}};
json j_array(c_array);
// [1, 2, 3, 4]

std::set<std::string> c_set {"one", "two", "three", "four", "one"};
json j_set(c_set); // only one entry for "one" is used
// ["four", "one", "three", "two"]

std::unordered_set<std::string> c_uset {"one", "two", "three", "four", "one"};
json j_uset(c_uset); // only one entry for "one" is used
// maybe ["two", "three", "four", "one"]

std::multiset<std::string> c_mset {"one", "two", "one", "four"};
json j_mset(c_mset); // both entries for "one" are used
// maybe ["one", "two", "one", "four"]

std::unordered_multiset<std::string> c_umset {"one", "two", "one", "four"};
json j_umset(c_umset); // both entries for "one" are used
// maybe ["one", "two", "one", "four"]

std::map转json、std::unordered转json

std::map<std::string, int> c_map { {"one", 1}, {"two", 2}, {"three", 3} };
json j_map(c_map);
// {"one": 1, "three": 3, "two": 2 }

std::unordered_map<const char*, double> c_umap { {"one", 1.2}, {"two", 2.3}, {"three", 3.4} };
json j_umap(c_umap);
// {"one": 1.2, "two": 2.3, "three": 3.4}

std::multimap<std::string, bool> c_mmap { {"one", true}, {"two", true}, {"three", false}, {"three", true} };
json j_mmap(c_mmap); // only one entry for key "three" is used
// maybe {"one": true, "two": true, "three": true}

std::unordered_multimap<std::string, bool> c_ummap { {"one", true}, {"two", true}, {"three", false}, {"three", true} };
json j_ummap(c_ummap); // only one entry for key "three" is used
// maybe {"one": true, "two": true, "three": true}
(adsbygoogle = window.adsbygoogle || []).push({});
Last Updated: 4/30/2023, 9:10:11 PM

← centos7断电无法启动，提示Internal error xfs XFSWANTCORRUPTED_GOTO 错误 →